import ast
import ast
import re

def listContainJudgeShort(l1, l2):
    """
    功能：以较短的长度为基准。存在包含关系的以大包含为准替代另一个值；
    逐个判断两个列表中是否存在包含关系，并返回结果;
    如果l1中存在l2中的元素，则将l2中的元素赋值给l1，否则将l1中的元素赋值给l2;
    优点：可处理："[]"形式；
    调用：
    l1 = "['2025.04.01-202', '', '2025.02.01-202', '2025.03.01-202']"
    l2 = "['2025.01.01-202', '2025', '2025.02.01-202', '2025.03.01-202', '2025.02.01-202', '2025.03.01-202']"
    l3, l4 = listContainJudgeL1(l1,l2)
    print("l3:", l3)
    print("l4:", l4)
    """
    l3 = []
    l4 = []
    for a, b in zip(l1, l2):
        if a in b:
            l3.append(b)
            l4.append(b)
        elif b in a:
            l3.append(a)
            l4.append(a)
        else:
            l3.append(a)
            l4.append(b)
    return l3, l4


def listContainJudgeL1(l1, l2):
    """
    功能：以l1长度为基准。存在包含关系的以大包含为准替代另一个值；
    以 l1 的长度为准，l2 不足的部分用 l1 对应位置的值填充。
    调用：
    l1 = ['2025.04.01-202', '', '2025.02.01-202', '2025.03.01-202']
    l2 = ['2025.01.01-202', '2025', '2025.02.01-202', '2025.03.01-202', '2025.02.01-202', '2025.03.01-202']
    l3, l4 = listContainJudgeL1(l1,l2)
    print("l3:", l3)
    print("l4:", l4)
    """
    l3 = []
    l4 = []
    for i, a in enumerate(l1):
        if i<len(l2):
            if a in l2[i]:
                l3.append(l2[i])
                l4.append(l2[i])
            elif l2[i] in a:
                l3.append(a)
                l4.append(a)
            else:
                l3.append(a)
                l4.append(l2[i])
        else:#长度不足时，用l1的值填充
            l3.append(a)
            l4.append(a)
    return l3, l4

def listContainJudgeL2(l1, l2):
    """
    以 l2 的长度为准，l1 不足的部分用 l2 对应位置的值填充。
    逐个判断两个列表中对应位置的元素是否存在包含关系：
    调用：
    l1 = ['2025.04.01-202', '', '2025.02.01-202', '2025.03.01-202']
    l2 = ['2025.01.01-202', '2025', '2025.02.01-202', '2025.03.01-202', '2025.02.01-202', '2025.03.01-202']

    l3, l4 = listContainJudgeL2(l1, l2)
    print("l3:", l3)
    print("l4:", l4)
    """
    l3 = []
    l4 = []
    # 确保 l1 长度与 l2 相同，不足部分用 l2 的值填充
    l1_adjusted = l1 + l2[len(l1):] if len(l1) < len(l2) else l1[:len(l2)]
    
    for a, b in zip(l1_adjusted, l2):
        if a in b:
            l3.append(b)
            l4.append(b)
        elif b in a:
            l3.append(a)
            l4.append(a)
        else:
            l3.append(a)
            l4.append(b)
    return l3, l4


# 字符串标准化函数
def normalize_string(s):
    if not isinstance(s, str):
        s = str(s)
    s = (s.replace('（', '(')
            .replace('）', ')')
            .replace('【', '[')
            .replace('】', ']'))
    return re.sub(r'\s+', ' ', s).strip()
 
 
# 输入转换函数
def convert_input(obj):
    if isinstance(obj, str):
        try:
            lst = ast.literal_eval(obj.strip())
            return [normalize_string(x) for x in lst] if isinstance(lst, list) else [normalize_string(lst)]
        except:
            return [normalize_string(obj)]
    elif isinstance(obj, list):
        return [normalize_string(x) for x in obj]
    return [normalize_string(obj)]   


def listContainJudgeShort(l1, l2):
    """
    功能：以较短的长度为基准。存在包含关系的以大包含为准替代另一个值；
    逐个判断两个列表中是否存在包含关系，并返回结果;
    如果l1中存在l2中的元素，则将l2中的元素赋值给l1，否则将l1中的元素赋值给l2;
    优点：可处理："[]"形式；
    调用：
    l1 = "['2025.04.01-202', '', '2025.02.01-202', '2025.03.01-202']"
    l2 = "['2025.01.01-202', '2025', '2025.02.01-202', '2025.03.01-202', '2025.02.01-202', '2025.03.01-202']"
    l3, l4 = listContainJudgeL1(l1,l2)
    print("l3:", l3)
    print("l4:", l4)
    """
    l3 = []
    l4 = []
    for a, b in zip(l1, l2):
        if a in b:
            l3.append(b)
            l4.append(b)
        elif b in a:
            l3.append(a)
            l4.append(a)
        else:
            l3.append(a)
            l4.append(b)
    return l3, l4


def listContainJudgeL1(l1, l2):
    """
    功能：以l1长度为基准。存在包含关系的以大包含为准替代另一个值；
    以 l1 的长度为准，l2 不足的部分用 l1 对应位置的值填充。
    调用：
    l1 = ['2025.04.01-202', '', '2025.02.01-202', '2025.03.01-202']
    l2 = ['2025.01.01-202', '2025', '2025.02.01-202', '2025.03.01-202', '2025.02.01-202', '2025.03.01-202']
    l3, l4 = listContainJudgeL1(l1,l2)
    print("l3:", l3)
    print("l4:", l4)
    """
    l3 = []
    l4 = []
    for i, a in enumerate(l1):
        if i<len(l2):
            if a in l2[i]:
                l3.append(l2[i])
                l4.append(l2[i])
            elif l2[i] in a:
                l3.append(a)
                l4.append(a)
            else:
                l3.append(a)
                l4.append(l2[i])
        else:#长度不足时，用l1的值填充
            l3.append(a)
            l4.append(a)
    return l3, l4

def listContainJudgeL2(l1, l2):
    """
    以 l2 的长度为准，l1 不足的部分用 l2 对应位置的值填充。
    逐个判断两个列表中对应位置的元素是否存在包含关系：
    调用：
    l1 = ['2025.04.01-202', '', '2025.02.01-202', '2025.03.01-202']
    l2 = ['2025.01.01-202', '2025', '2025.02.01-202', '2025.03.01-202', '2025.02.01-202', '2025.03.01-202']

    l3, l4 = listContainJudgeL2(l1, l2)
    print("l3:", l3)
    print("l4:", l4)
    """
    l3 = []
    l4 = []
    # 确保 l1 长度与 l2 相同，不足部分用 l2 的值填充
    l1_adjusted = l1 + l2[len(l1):] if len(l1) < len(l2) else l1[:len(l2)]
    
    for a, b in zip(l1_adjusted, l2):
        if a in b:
            l3.append(b)
            l4.append(b)
        elif b in a:
            l3.append(a)
            l4.append(a)
        else:
            l3.append(a)
            l4.append(b)
    return l3, l4


def listSafeContainJudgeL1(l1, l2):
    """
    增强版安全比较函数（带字符串标准化处理）
    
    参数：
        l1, l2: 可以是列表，或字符串形式的列表（如 "['a', 'b']"）
    
    返回：
        l3, l4: 处理后的两个列表
        
    功能说明：
        1. 自动识别并转换输入格式
        2. 字符串标准化处理（统一括号、去除空白）
        3. 以l1长度为准，l2不足时用l1的值填充
        4. 智能元素比较（包含关系判断）
        调用：
# model: ['ZH-283(不含软件及D5F接口)']", "['Y-TZZJ-256M', 'ZHZJ-639', 'ZC/DY/8-12V', 'ZH-283']"]
l1 ="['Y-TZZJ-256M', 'ZHZJ-639(不含软件)', 'ZC/DY/8-12V', 'ZH-283(不含软件及D5F接口)']"
l2= "['Y-TZZJ-256M', 'ZHZJ-639', 'ZC/DY/8-12V', 'ZH-283']"
l3,l4=listSafeContainJudgeL1(l1,l2)
# l3, l4 = listSafeContainJudge(l1, l2, "left")
print("l3:", l3)
print("l4:", l4)
    """
    # 处理输入数据
    l1 = convert_input(l1)
    l2 = convert_input(l2)
    
    # 执行比较逻辑
    l3, l4 = [], []
    for i, a in enumerate(l1):
        b = l2[i] if i < len(l2) else a
        if a in b:
            l3.append(b)
            l4.append(b)
        elif b in a:
            l3.append(a)
            l4.append(a)
        else:
            l3.append(a)
            l4.append(b)
    
    return l3, l4


def listSafeContainJudgeL2(l1, l2):
    """
    增强版函数：智能处理输入（支持字符串列表和直接列表），以l2长度为基准比较
    
    参数：
        l1, l2: 可以是列表，或字符串形式的列表（如 "['a', 'b']"）
    
    返回：
        l3, l4: 处理后的两个列表
        
    功能说明：
        1. 自动识别字符串形式的列表并转换
        2. 以l2长度为准，l1不足时用l2的值填充
        3. 元素比较规则：
           - 若l1[i]包含于l2[i]，取l2[i]
           - 若l2[i]包含于l1[i]，取l1[i]
           - 否则保持各自原值
    """
    # 智能转换输入为列表（内部函数）
    def convert_input(obj):
        if isinstance(obj, str):
            try:
                return ast.literal_eval(obj.strip())
            except (ValueError, SyntaxError):
                return [obj]  # 如果不是合法列表字符串，当作单元素列表
        elif isinstance(obj, list):
            return obj
        else:
            return [str(obj)]  # 其他类型转为单元素列表

    # 转换输入数据
    l1 = convert_input(l1)
    l2 = convert_input(l2)
    
    # 调整l1长度与l2一致（不足补l2的值，超出则截断）
    l1_adjusted = l1 + l2[len(l1):] if len(l1) < len(l2) else l1[:len(l2)]
    
    l3, l4 = [], []
    for a, b in zip(l1_adjusted, l2):
        if a in b:
            l3.append(b)
            l4.append(b)
        elif b in a:
            l3.append(a)
            l4.append(a)
        else:
            l3.append(a)
            l4.append(b)
    
    return l3, l4


def listSafeContainJudge(l1, l2, base="left"):
    """
    通用安全比较函数 - 可根据参数选择以左侧(l1)或右侧(l2)列表为基准
    
    参数：
        l1, l2: 可以是列表，或字符串形式的列表（如 "['a', 'b']"）
        base: 基准选择，可选值：
              - "left" 或 "l1": 以l1长度为基准（默认）
              - "right" 或 "l2": 以l2长度为基准
              - "short": 以较短列表为基准
              - "long": 以较长列表为基准
    
    返回：
        l3, l4: 处理后的两个列表
        
    功能说明：
        1. 自动识别并转换输入格式
        2. 字符串标准化处理（统一括号、去除空白）
        3. 根据base参数选择基准列表
        4. 智能元素比较（包含关系判断）
        
    调用示例1：
        l1 = "['ZHZJ-639(不含软件)', 'Y-TZZJ-256M']"
        l2 = "['ZHJZJ-639(不含软件)', 'Y-TZZJ-256M', '额外元素']"
        
        # 以l1为基准
        l3, l4 = listSafeContainJudge(l1, l2, "left")
        
        # 以l2为基准
        l3, l4 = listSafeContainJudge(l1, l2, "right")
        
        # 以较短列表为基准
        l3, l4 = listSafeContainJudge(l1, l2, "short")
    调用示例2：
    l1 = ['ZHZJ-639(不含软件)', 'Y-TZZJ-256M',"1"]
    l2 = ['ZHJZJ-639(不含软件)', 'Y-TZZJ-256M']
    l3, l4 = listSafeContainJudge(l1, l2, "right")
    print("l3:", l3)
    print("l4:", l4)
    """

    # 处理输入数据
    l1_normalized = convert_input(l1)
    l2_normalized = convert_input(l2)
    
    # 确定基准列表
    base = base.lower()
    if base in ["right", "l2", "r"]:
        # 以l2为基准
        base_list = l2_normalized
        other_list = l1_normalized
        # 调整l1长度与l2一致
        l1_adjusted = l1_normalized + l2_normalized[len(l1_normalized):] if len(l1_normalized) < len(l2_normalized) else l1_normalized[:len(l2_normalized)]
        l2_adjusted = l2_normalized
    elif base in ["short", "s"]:
        # 以较短列表为基准
        if len(l1_normalized) <= len(l2_normalized):
            base_list = l1_normalized
            other_list = l2_normalized
            l1_adjusted = l1_normalized
            l2_adjusted = l2_normalized[:len(l1_normalized)]
        else:
            base_list = l2_normalized
            other_list = l1_normalized
            l1_adjusted = l1_normalized[:len(l2_normalized)]
            l2_adjusted = l2_normalized
    elif base in ["long", "l"]:
        # 以较长列表为基准
        if len(l1_normalized) >= len(l2_normalized):
            base_list = l1_normalized
            other_list = l2_normalized
            l1_adjusted = l1_normalized
            l2_adjusted = l2_normalized + l1_normalized[len(l2_normalized):]
        else:
            base_list = l2_normalized
            other_list = l1_normalized
            l1_adjusted = l1_normalized + l2_normalized[len(l1_normalized):]
            l2_adjusted = l2_normalized
    else:
        # 默认以l1为基准
        base_list = l1_normalized
        other_list = l2_normalized
        l1_adjusted = l1_normalized
        l2_adjusted = l2_normalized[:len(l1_normalized)] if len(l2_normalized) > len(l1_normalized) else l2_normalized + [l1_normalized[i] for i in range(len(l2_normalized), len(l1_normalized))]
    
    # 执行比较逻辑
    l3, l4 = [], []
    for a, b in zip(l1_adjusted, l2_adjusted):
        if a in b:
            l3.append(b)
            l4.append(b)
        elif b in a:
            l3.append(a)
            l4.append(a)
        else:
            l3.append(a)
            l4.append(b)
    
    return l3, l4





